#include <iostream>
#include <pthread.h>
#include <functional>
#include <string>
#include <unistd.h>
#include <vector>

// 线程库模块
namespace pthread_moudle
{
    template <class T>
    using func_t = std::function<void(T&)>;

    template <class T>
    class Thread
    {
    public:
        Thread(func_t<T> func, T &data, std::string name)
            : _func(func), _data(data), _name(name),_stop(true)
        {
        }

        // 执行功能函数
        void excute()
        {
            _func(_data);
        }

        static void *thread_rountine(void *args)
        {
            Thread<T> *selfthread = static_cast<Thread<T> *>(args); // 将args显式强转为线程类型
            selfthread->excute();
            return nullptr;
        }

        // 启动线程，并返回启动结果
        bool start()
        {
            int n = pthread_create(&_tid, nullptr, thread_rountine, this); // 创建线程，线程函数为thread_routine,传入*this，
            if (n == 0)
            {
                _stop = false;
                std::cout<<_name<<"start success...."<<std::endl;
                return true;
            }
            else
            {
                std::cout << "start fail" << std::endl;
                return false;
            }
        }

        // 非静态成员函数会默认传入this，但线程函数只有一个参数
        // 同时，静态成员函数无法直接访问对象成员，需要传入

        void detach()
        {
            if (!_stop)
            {
                pthread_detach(_tid);
            }
        }
        // 等待进程
        void join()
        {
            if (!_stop)
                pthread_join(_tid, nullptr);
        }
        ~Thread()
        {
        }

    private:
        pthread_t _tid;     // 线程的tid
        T& _data;           // 传入线程函数的数据
        std::string _name; // 线程的名字
        bool _stop ;  // 线程的运行状态
        func_t<T> _func;    // 线程函数调用的函数，线程最终执行的功能函数
    };
}
